home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / etc / john / john.conf
Text File  |  2005-10-18  |  12KB  |  577 lines
  1. #
  2. # This file is part of John the Ripper password cracker,
  3. # Copyright (c) 1996-2003 by Solar Designer
  4. #
  5.  
  6. [Options]
  7. # Wordlist file name, to be used in batch mode
  8. Wordlist = $JOHN/password.lst
  9. # Use idle cycles only
  10. Idle = N
  11. # Crash recovery file saving delay in seconds
  12. Save = 600
  13. # Beep when a password is found (who needs this anyway?)
  14. Beep = N
  15.  
  16. # "Single crack" mode rules
  17. [List.Rules:Single]
  18. # Simple rules come first...
  19. :
  20. -s x**
  21. -c (?acQ
  22. -c lQ
  23. -s-c x**MlQ
  24. # These were not included in crackers I've seen, but are pretty efficient,
  25. # so I include them near the beginning
  26. >6'6
  27. >7l'7
  28. >6/?ul'6
  29. >5'5
  30. # Weird order, eh? Can't do anything about it, the order is based on the
  31. # number of successful cracks...
  32. <*d
  33. rc
  34. <*dMcQ
  35. >5/?ul'5
  36. uQ
  37. r(?al
  38. <*!?A[lc]p
  39. <*cQd
  40. >7/?u'7
  41. >4l'4
  42. <+(?lcr
  43. <+r(?lcr
  44. >3'3
  45. >4/?u'4
  46. >3/?ul'3
  47. uQr
  48. <*lQf
  49. # About 50% of single-mode-crackable passwords get cracked by now...
  50. >2x12
  51. >3x13
  52. >4x14
  53. >5x15
  54. >6x16
  55. >7x17
  56. >8x18
  57. >3x22
  58. >4x23
  59. >5x24
  60. >6x25
  61. >7x26
  62. >8x27
  63. >9x28
  64. >4x32
  65. >5x33
  66. >6x34
  67. >7x35
  68. >8x36
  69. >9x37
  70. >2/?ulx12
  71. >3/?ulx13
  72. >4/?ulx14
  73. >5/?ulx15
  74. >6/?ulx16
  75. >7/?ulx17
  76. >8/?ulx18
  77. >3/?ulx22
  78. >4/?ulx23
  79. >5/?ulx24
  80. >6/?ulx25
  81. >7/?ulx26
  82. >8/?ulx27
  83. >9/?ulx28
  84. >4/?ulx32
  85. >5/?ulx33
  86. >6/?ulx34
  87. >7/?ulx35
  88. >8/?ulx36
  89. >9/?ulx37
  90. # Now to the suffix stuff...
  91. <*l$[1-9!0a-z"-/:-@\[-`{-~]
  92. <*(?ac$[1-9!0a-z"-/:-@\[-`{-~]
  93. <*lr$[1-9!]
  94. <*/?au$[1-9!]
  95. <-l$!$!
  96. <-(?ac$!$!
  97. l$!<-$!$!
  98. (?ac$!<-$!$!
  99. # Removing vowels...
  100. /?v@?v>2l
  101. /?v@?v>2(?ac
  102. /?v@?v>2<*d
  103. # crack -> cracked, crack -> cracking
  104. <*l[PI]
  105. <*l[PI](?ac
  106. # mary -> marie
  107. <*(?a[lc])yro0ir$e
  108. # marie -> mary
  109. <*(?a[lc])er=1iD0o0yr
  110. # The following 3l33t rules are based on original Crack's dicts.rules
  111. l/asa4[:c]
  112. l/ese3[:c]
  113. l/lsl1[:c]
  114. l/oso0[:c]
  115. l/sss$[:c]
  116. l/asa4/ese3[:c]
  117. l/asa4/lsl1[:c]
  118. l/asa4/oso0[:c]
  119. l/asa4/sss$[:c]
  120. l/ese3/lsl1[:c]
  121. l/ese3/oso0[:c]
  122. l/ese3/sss$[:c]
  123. l/lsl1/oso0[:c]
  124. l/lsl1/sss$[:c]
  125. l/oso0/sss$[:c]
  126. l/asa4/ese3/lsl1[:c]
  127. l/asa4/ese3/oso0[:c]
  128. l/asa4/ese3/sss$[:c]
  129. l/asa4/lsl1/oso0[:c]
  130. l/asa4/lsl1/sss$[:c]
  131. l/asa4/oso0/sss$[:c]
  132. l/ese3/lsl1/oso0[:c]
  133. l/ese3/lsl1/sss$[:c]
  134. l/ese3/oso0/sss$[:c]
  135. l/lsl1/oso0/sss$[:c]
  136. l/asa4/ese3/lsl1/oso0[:c]
  137. l/asa4/ese3/lsl1/sss$[:c]
  138. l/asa4/ese3/oso0/sss$[:c]
  139. l/asa4/lsl1/oso0/sss$[:c]
  140. l/ese3/lsl1/oso0/sss$[:c]
  141. l/asa4/ese3/lsl1/oso0/sss$[:c]
  142. # Now to the prefix stuff...
  143. l^[1a-z2-90]
  144. lQ^[A-Z]
  145. ^[A-Z]
  146. l^["-/:-@\[-`{-~]
  147. <9(?a[lc]^e^h^[tT]
  148. <9(?a[lc]^y^m^[aA]
  149. <9(?a[lc]^r^[mdMD]
  150. <9(?a[lc]^.^r^[mdMD]
  151. <9(?a[lc]^_^_
  152. <-!?Alp^[240-9]
  153. # Some word pair rules...
  154. # johnsmith -> JohnSmith, johnSmith
  155. (?a2(?ac1[cl]
  156. # JohnSmith -> john smith, john_smith, john-smith
  157. 1<-$[ _\-]+l
  158. # JohnSmith -> John smith, John_smith, John-smith
  159. 1<-(?ac$[ _\-]2l
  160. # JohnSmith -> john Smith, john_Smith, john-Smith
  161. 1<-l$[ _\-]2(?ac
  162. # johnsmith -> John Smith, John_Smith, John-Smith
  163. 1<-(?ac$[ _\-]2(?ac
  164. # Applying different simple rules to each of the two words
  165. 1[ur]2l
  166. 2(?ac1[ur]
  167. 1l2[ur]
  168. 1(?ac2[ur]
  169. # jsmith -> smithj, etc...
  170. (?a[lc][{}]
  171. (?a[lc]}}
  172. (?a[lc]{{
  173. # Toggle case...
  174. T[1-7]Q
  175. lMT[1-7]Q
  176. >2[lu]MT0T2T4T6T8Q
  177. # Deleting chars...
  178. D[1-7]Q
  179. D[1-7]Q/?ul
  180. D[1-7]Q(?ac
  181. # Inserting a dot...
  182. >3(?a[lc]i[12].
  183. # More suffix stuff...
  184. <-l$[190]$[0-9]
  185. <-(?ac$[190]$[0-9]
  186. <-l$[782]$[0-9]
  187. <-(?ac$[782]$[0-9]
  188. <*(?a[lc]$[A-Z]
  189. # cracking -> CRACKiNG
  190. u/IsIi
  191. # Crack96 -> cRACK96
  192. CQ
  193. # Crack96 -> cRACK(^
  194. SQ
  195. # Crack96 -> CRaCK96
  196. /?vVQ
  197. # Really weird charset conversions, like "england" -> "rmh;smf"
  198. :[RL]Q
  199. lQ[RL]
  200. (?acQ[RL]
  201. RRQ
  202. LLQ
  203. # Both prefixing and suffixing...
  204. <-l^1$1
  205. <-l^!$!
  206. <-l^@$@
  207. <-l^#$#
  208. <-l^$$$
  209. <-l^%$%
  210. <-l^^$^
  211. <-l^&$&
  212. <-l^*$*
  213. <-l^($)
  214. <-l^-$-
  215. <-l^=$=
  216. <-l^_$_
  217. <-l^+$+
  218. <-l^.$.
  219. <-l^?$?
  220. <-l^{$}
  221. <-l^\[$]
  222. <-l^<$>
  223. <-l^|$|
  224. <-l^:$:
  225. <-l^'$'
  226. <-l^"$"
  227. # The rest of two-digit suffix stuff, less common numbers...
  228. <-l$[63-5]$[0-9]
  229. <-(?ac$[63-5]$[0-9]
  230. # Some three-digit numbers...
  231. (?a[lc]$0<-$0$7
  232. (?a[lc]$1<-$1$1
  233. (?a[lc]$1<-$2$3
  234. (?a[lc]$2<-$2$2
  235. (?a[lc]$3<-$3$3
  236. (?a[lc]$4<-$4$4
  237. (?a[lc]$5<-$5$5
  238. (?a[lc]$6<-$6$6
  239. (?a[lc]$7<-$7$7
  240. (?a[lc]$8<-$8$8
  241. (?a[lc]$9<-$9$9
  242. # Some [birth] years...
  243. l$1<-$9$[7-96-0]>-
  244. l$2<-$0$0>-
  245. l$1$9<-$[7-9]$[0-9]
  246. l$2$0<-$0$[0-9]
  247. l$1$9<-$[6-0]$[9-0]
  248. # Uncomment the following lines if you're really crazy
  249. ;# Insert/overstrike some characters...
  250. ;!?Ali[1-6][a-z]
  251. ;!?Alo[0-7][a-z]
  252. ;# Toggle case everywhere...
  253. ;lMT[*7]T[*6]T[*5]T[*4]T[*3]T[*2]T[*1]T[*0]Q
  254. ;# Very slow stuff...
  255. ;l$[1-90]<-$[0-9]$[0-9]
  256. ;(?ac$[1-90]<-$[0-9]$[0-9]
  257. ;<-l$[a-z]$[a-z]
  258. ;<9l^[a-z]^[a-z]
  259. ;<-l^[a-z]$[a-z]
  260.  
  261. # Wordlist mode rules
  262. [List.Rules:Wordlist]
  263. # Try words as they are
  264. :
  265. # Lowercase every pure alphanumeric word
  266. -c >3!?XlQ
  267. # Capitalize every pure alphanumeric word
  268. -c >2(?a!?XcQ
  269. # Lowercase and pluralize pure alphabetic words
  270. <*>2!?Alp
  271. # Lowercase pure alphabetic words and append '1'
  272. <*>2!?Al$1
  273. # Capitalize pure alphabetic words and append '1'
  274. -c <*>2!?Ac$1
  275. # Duplicate reasonably short pure alphabetic words (fred -> fredfred)
  276. <7>1!?Ald
  277. # Lowercase and reverse pure alphabetic words
  278. >3!?AlMrQ
  279. # Prefix pure alphabetic words with '1'
  280. >2!?Al^1
  281. # Uppercase pure alphanumeric words
  282. -c >2!?XuQ
  283. # Lowercase pure alphabetic words and append a digit or simple punctuation
  284. <*>2!?Al$[2!37954860.?]
  285. # Words containing punctuation, which is then squeezed out, lowercase
  286. /?p@?p>3l
  287. # Words with vowels removed, lowercase
  288. /?v@?v>3l
  289. # Words containing whitespace, which is then squeezed out, lowercase
  290. /?w@?w>3l
  291. # Capitalize and duplicate short pure alphabetic words (fred -> FredFred)
  292. -c <7>1!?Acd
  293. # Capitalize and reverse pure alphabetic words (fred -> derF)
  294. -c <+>2!?Acr
  295. # Reverse and capitalize pure alphabetic words (fred -> Derf)
  296. -c >2!?AMrQc
  297. # Lowercase and reflect pure alphabetic words (fred -> fredderf)
  298. <7>1!?AlMrQrf
  299. # Uppercase the last letter of pure alphabetic words (fred -> freD)
  300. -c <+>2!?AMrQcr
  301. # Prefix pure alphabetic words with '2' or '4'
  302. >2!?Al^[24]
  303. # Capitalize pure alphabetic words and append a digit or simple punctuation
  304. -c <*>2!?Ac$[2!3957468.?0]
  305. # Prefix pure alphabetic words with digits
  306. >2!?Al^[379568]
  307. # Capitalize and pluralize pure alphabetic words of reasonable length
  308. -c <*>2!?Acp
  309. # Lowercase/capitalize pure alphabetic words of reasonable length and convert:
  310. # crack -> cracked, crack -> cracking
  311. <*>2!?Al[PI]
  312. -c <*>2!?Ac[PI]
  313. # Try the second half of split passwords
  314. -s x**
  315. -s-c x**MlQ
  316.  
  317. # Incremental modes
  318. [Incremental:All]
  319. File = $JOHN/all.chr
  320. MinLen = 0
  321. MaxLen = 8
  322. CharCount = 95
  323.  
  324. [Incremental:Alpha]
  325. File = $JOHN/alpha.chr
  326. MinLen = 1
  327. MaxLen = 8
  328. CharCount = 26
  329.  
  330. [Incremental:Digits]
  331. File = $JOHN/digits.chr
  332. MinLen = 1
  333. MaxLen = 8
  334. CharCount = 10
  335.  
  336. [Incremental:LanMan]
  337. File = $JOHN/lanman.chr
  338. MinLen = 0
  339. MaxLen = 7
  340. CharCount = 69
  341.  
  342. # Some pre-defined word filters
  343. [List.External:Filter_Alpha]
  344. void filter()
  345. {
  346.     int i, c;
  347.  
  348.     i = 0;
  349.     while (c = word[i++])
  350.     if (c < 'a' || c > 'z') {
  351.         word = 0; return;
  352.     }
  353. }
  354.  
  355. [List.External:Filter_Digits]
  356. void filter()
  357. {
  358.     int i, c;
  359.  
  360.     i = 0;
  361.     while (c = word[i++])
  362.     if (c < '0' || c > '9') {
  363.         word = 0; return;
  364.     }
  365. }
  366.  
  367. [List.External:Filter_LanMan]
  368. void filter()
  369. {
  370.     int i, c;
  371.  
  372.     word[7] = 0;            // Truncate at 7 characters
  373.  
  374.     i = 0;                // Convert to uppercase
  375.     while (c = word[i]) {
  376.         if (c >= 'a' && c <= 'z') word[i] &= 0xDF;
  377.         i++;
  378.     }
  379. }
  380.  
  381. # A simple cracker for LM hashes
  382. [List.External:LanMan]
  383. int length;                // Current length
  384.  
  385. void init()
  386. {
  387.     word[0] = 'A' - 1;        // Start with "A"
  388.     word[length = 1] = 0;
  389. }
  390.  
  391. void generate()
  392. {
  393.     int i;
  394.  
  395.     i = length - 1;            // Start from the last character
  396.     while (++word[i] > 'Z')        // Try to increase it
  397.     if (i)                // Overflow here, any more positions?
  398.         word[i--] = 'A';    // Yes, move to the left, and repeat
  399.     else                // No
  400.     if (length < 7) {
  401.         word[i = ++length] = 0;    // Switch to the next length
  402.         while (i--)
  403.             word[i] = 'A';
  404.         return;
  405.     } else {
  406.         word = 0; return;    // We're done
  407.     }
  408. }
  409.  
  410. void restore()
  411. {
  412.     length = 0;            // Calculate the length
  413.     while (word[length]) length++;
  414. }
  415.  
  416. # Strip 0.5 ("Secure Tool for Recalling Important Passwords") cracker,
  417. # based on analysis done by Thomas Roessler and Ian Goldberg. This will
  418. # crack passwords you may have generated with Strip, other uses of Strip
  419. # are unaffected.
  420. # See http://www.zetetic.net/products.html for information on Strip.
  421. [List.External:Strip]
  422. int minlength, maxlength, mintype, maxtype;
  423. int crack_seed, length, type;
  424. int count, charset[128];
  425.  
  426. void init()
  427. {
  428.     int c;
  429.  
  430. /* Password lengths to try; Strip can generate passwords of 4 to 16
  431.  * characters, but traditional crypt(3) hashes are limited to 8. */
  432.     minlength = 8;    // 4
  433.     maxlength = 8;    // 16
  434.  
  435. /* Password types to try (Numeric, Alpha-Num, Alpha-Num w/ Meta). */
  436.     mintype = 1;    // 0
  437.     maxtype = 1;    // 2
  438.  
  439.     crack_seed = 0x10000;
  440.     length = minlength - 1;
  441.     type = mintype;
  442.  
  443.     count = 0;
  444.     c = '0'; while (c <= '9') charset[count++] = c++;
  445. }
  446.  
  447. void generate()
  448. {
  449.     int seed, random;
  450.     int i, c;
  451.  
  452.     if (crack_seed > 0xffff) {
  453.         crack_seed = 0;
  454.  
  455.         if (++length > maxlength) {
  456.             length = minlength;
  457.  
  458.             if (++type > maxtype) {
  459.                 word[0] = 0;
  460.                 return;
  461.             }
  462.         }
  463.  
  464.         count = 10;
  465.         if (type >= 1) {
  466.             c = 'a'; while (c <= 'f') charset[count++] = c++;
  467.             c = 'h'; while (c <= 'z') charset[count++] = c++;
  468.             c = 'A'; while (c <= 'Z') charset[count++] = c++;
  469.         }
  470.         if (type == 2) {
  471.             charset[count++] = '!';
  472.             c = '#'; while (c <= '&') charset[count++] = c++;
  473.             c = '('; while (c <= '/') charset[count++] = c++;
  474.             c = '<'; while (c <= '>') charset[count++] = c++;
  475.             charset[count++] = '?'; charset[count++] = '@';
  476.             charset[count++] = '['; charset[count++] = ']';
  477.             charset[count++] = '^'; charset[count++] = '_';
  478.             c = '{'; while (c <= '~') charset[count++] = c++;
  479.         }
  480.     }
  481.  
  482.     seed = (crack_seed++ << 16 >> 16) * 22695477 + 1;
  483.  
  484.     i = 0;
  485.     while (i < length) {
  486.         random = ((seed = seed * 22695477 + 1) >> 16) & 0x7fff;
  487.         word[i++] = charset[random % count];
  488.     }
  489.  
  490.     word[i] = 0;
  491. }
  492.  
  493. # Useful external mode example
  494. [List.External:Double]
  495. /*
  496.  * This cracking mode tries all the possible duplicated lowercase alphabetic
  497.  * "words" of up to 8 characters long. Since word halves are the same, it
  498.  * only has to try about 500,000 words.
  499.  */
  500.  
  501. /* Global variables: current length and word */
  502. int length, current[9];
  503.  
  504. /* Called at startup to initialize the global variables */
  505. void init()
  506. {
  507.     int i;
  508.  
  509.     i = length = 2;            // Start with 4 character long words
  510.     while (i--) current[i] = 'a';    // Set our half-word to "aa"
  511. }
  512.  
  513. /* Generates a new word */
  514. void generate()
  515. {
  516.     int i;
  517.  
  518. /* Export last generated word, duplicating it at the same time; here "word"
  519.  * is a pre-defined external variable. */
  520.     word[(i = length) << 1] = 0;
  521.     while (i--) word[length + i] = word[i] = current[i];
  522.  
  523. /* Generate a new word */
  524.     i = length - 1;            // Start from the last character
  525.     while (++current[i] > 'z')    // Try to increase it
  526.     if (i)                // Overflow here, any more positions?
  527.         current[i--] = 'a';    // Yes, move to the left, and repeat
  528.     else {                // No
  529.         current = 0;        // Request a length switch
  530.         break;            // Break out of the loop
  531.     }
  532.  
  533. /* Switch to the next length, unless we were generating 8 character long
  534.  * words already. */
  535.     if (!current && length < 4) {
  536.         i = ++length;
  537.         while (i--) current[i] = 'a';
  538.     }
  539. }
  540.  
  541. /* Called when restoring an interrupted session */
  542. void restore()
  543. {
  544.     int i;
  545.  
  546. /* Import the word back */
  547.     i = 0;
  548.     while (current[i] = word[i]) i++;
  549.  
  550. /* ...and calculate the half-word length */
  551.     length = i >> 1;
  552. }
  553.  
  554. # Simple parallel processing example
  555. [List.External:Parallel]
  556. /*
  557.  * This word filter makes John process some of the words only, for running
  558.  * multiple instances on different CPUs. It can be used with any cracking
  559.  * mode except for "single crack". Note: this is not a good solution, but
  560.  * is just an example of what can be done with word filters.
  561.  */
  562.  
  563. int node, total;            // This node's number, and node count
  564. int number;                // Current word number
  565.  
  566. void init()
  567. {
  568.     node = 1; total = 2;        // Node 1 of 2, change as appropriate
  569.     number = node - 1;        // Speedup the filter a bit
  570. }
  571.  
  572. void filter()
  573. {
  574.     if (number++ % total)        // Word for a different node?
  575.         word = 0;        // Yes, skip it
  576. }
  577.